home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Special 25 / AMIGAplus Sonderheft 25 (2000)(Falke)(DE)(Track 1 of 4)[!].iso / Updates / PowerPC / DeMimePPC / de-mime.c < prev    next >
C/C++ Source or Header  |  1998-03-21  |  7KB  |  292 lines
  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <dos.h>
  5. #include <string.h>
  6. #include <io.h>
  7. #include <fcntl.h>
  8. #include <ctype.h>
  9. #include <dir.h>
  10.  
  11. #define max_line_length 250
  12.  
  13. extern int errno, _doserrno;
  14.  
  15. int ValidMIME (char *);
  16.  
  17. char  * ReadInput( FILE * __stream, char * __s, int _q, int * __n);
  18.  
  19. char char_set[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  20. int char_table[128];
  21.  
  22. main (int argc, char *argv[])
  23. {
  24.      FILE *inputfile;
  25.      char inputpath[MAXPATH+1];
  26.      char inputfilename[MAXPATH+1];
  27.      char input_string[max_line_length];
  28.      char * tempchar;
  29.      char argoutputfilename[MAXPATH+1];
  30.      int files_processed = 0;
  31.      int ii,jj;
  32.      int line_counter = 0;
  33.  
  34.      for (ii=0 ; ii<128 ; ++ii)
  35.           char_table[ii] = -1;
  36.      tempchar = char_set;
  37.      for (ii=0 ; ii <= strlen(char_set) ; ii++)
  38.           {
  39.             char_table[*tempchar++] = ii;
  40.           }
  41.  
  42.      if (argc<2 || argc>3)
  43.          {
  44.           printf("Invalid number of parameters %u\n",argc-1);
  45.           printf("Usage: de-mime inputfile [outputfile]\n");
  46.           return 8;
  47.          }
  48.      else
  49.           strcpy(inputfilename,argv[1]);
  50.      if (argc > 2)
  51.           {
  52.             strcpy(argoutputfilename,argv[2]);
  53.           }
  54.  
  55.      inputfile = fopen(inputfilename,"rt");
  56.  
  57.      if (inputfile == NULL)
  58.           {
  59.             printf("Input file - %s - could not be opened\n",inputfilename);
  60.             return 4;
  61.           }
  62.  
  63.      tempchar = strrchr(inputfilename,'\\') ;
  64.  
  65.      if  (tempchar != NULL)
  66.           {
  67.             ii = (int) (tempchar-inputfilename+1);
  68.             strncpy(inputpath,inputfilename,ii);
  69.             inputpath[ii] = '\0';
  70.           }
  71.      else
  72.           {
  73.             inputpath[0] = '\0';
  74.           }
  75.  
  76.      if (ReadInput(inputfile,input_string,max_line_length,&line_counter) == NULL)
  77.           {
  78.             printf("File %s is empty\n",argv[1]);
  79.             fclose(inputfile);
  80.             return 4;
  81.           }
  82.  
  83.      for (;feof(inputfile)==0;)
  84.           {
  85.             char *nameptr;
  86.             char suggestedfilename[MAXPATH+1];
  87.             char outputfilename[MAXPATH+1];
  88.             FILE *outputfile;
  89.             int ii;
  90.             int start_line;
  91.             long int output_size;
  92.             char quotechar;
  93.  
  94.             suggestedfilename[0] = '\0';
  95.  
  96.             for ( ; (!ValidMIME(input_string) || strlen(input_string) < 12) &&
  97.                       feof(inputfile)==0 ; )
  98.                  {
  99.                   nameptr = strstr(input_string,"name=");
  100.                   if (nameptr != NULL)
  101.                         {
  102.                          strcpy(suggestedfilename,nameptr+6);
  103.                          nameptr = nameptr+5;
  104.                          quotechar = *nameptr;
  105.                          for (ii=0 ; suggestedfilename[ii]!=quotechar ; ii++)
  106.                               ;
  107.                          suggestedfilename[ii] = '\0';
  108.                         }
  109.                   ReadInput(inputfile,input_string,max_line_length,&line_counter);
  110.                  }
  111.  
  112.             if (feof(inputfile) != 0)
  113.                  break;
  114.  
  115.             if (suggestedfilename[0] != '\0')
  116.                  {
  117.                   strcpy(outputfilename,inputpath);
  118.                   strcat(outputfilename,suggestedfilename);
  119.                  }
  120.             else
  121.                  {
  122.                   if (argc > 2)
  123.                         {
  124.                          for (ii = 0; (argoutputfilename[ii] != '\\') &&
  125.                                             (ii < strlen(argoutputfilename)) ; ++ii) ;
  126.                          if (argoutputfilename[ii] != '\\')
  127.                               {
  128.                                 strcpy(outputfilename,inputpath);
  129.                                 strcat(outputfilename,argoutputfilename);
  130.                               }
  131.                          else
  132.                               {
  133.                                 strcpy(outputfilename,argoutputfilename);
  134.                               }
  135.                         }
  136.                   else
  137.                         {
  138.                          outputfilename[0] = '\0';
  139.                         }
  140.                  }
  141.  
  142.             for (outputfile = NULL ; outputfile == NULL ; )
  143.                  {
  144.                   if (outputfilename[0] != '\0')
  145.                         {
  146.                          outputfile=fopen(outputfilename,"rb");
  147.                          if (outputfile != NULL)
  148.                               {
  149.                                 printf("Outputfile %s already exists\n",outputfilename);
  150.                                 fclose(outputfile);
  151.                                 outputfile = NULL;
  152.                               }
  153.                          else
  154.                               {
  155.                                 outputfile=fopen(outputfilename,"wb");
  156.                                 if (outputfile == NULL)
  157.                                      {
  158.                                       printf("Error creating output file %s",
  159.                                                                              outputfilename);
  160.                                       printf(" Errno=%d, _doserrno=%d\n",
  161.                                                                             errno,_doserrno);
  162.                                      }
  163.                               }
  164.                         }
  165.                   else
  166.                         {
  167.                          printf("Output filename not specified\n");
  168.                         }
  169.                   if (outputfile == NULL)
  170.                         {
  171.                          printf("Enter outputfile name: ");
  172.                          for (ii = 0; ii < 64; ++ii)
  173.                               {
  174.                                 int GottonChar;
  175.                                 GottonChar = getchar();
  176.                                 suggestedfilename[ii] = GottonChar;
  177.                                 if (GottonChar == '\n' || GottonChar == EOF)
  178.                                      {
  179.                                       suggestedfilename[ii] = '\0';
  180.                                       break;
  181.                                      }
  182.                               }
  183.                          for (ii = 0; (suggestedfilename[ii] != '\\') &&
  184.                                             (ii < strlen(suggestedfilename)) ; ++ii)
  185.                               ;
  186.                          if (suggestedfilename[ii] != '\\')
  187.                               {
  188.                                 strcpy(outputfilename,inputpath);
  189.                                 strcat(outputfilename,suggestedfilename);
  190.                               }
  191.                          else
  192.                               {
  193.                                 strcpy(outputfilename,suggestedfilename);
  194.                               }
  195.                         }
  196.                  }
  197.  
  198.             printf("Creating output file #%d - %s - starting at line %d\n",
  199.                                       ++files_processed,outputfilename,line_counter);
  200.  
  201.             start_line = line_counter;
  202.             output_size = 0;
  203.  
  204.             for ( ; feof(inputfile) == 0 ; )
  205.                  {
  206.                   char output_buffer[3];
  207.                   int output_length;
  208.                   char * charptr;
  209.                   int ii;
  210.                   int sextet[4];
  211.  
  212.                   charptr = &input_string[0];
  213.  
  214.                   for (ii=0 ; ii<strlen(input_string); ii=ii+4)
  215.                         {
  216.                          for (jj=0; jj<4; jj++)
  217.                               {
  218.                                 sextet[jj] = char_table[*charptr++];
  219.                               }
  220.                          if (sextet[0] < 0)
  221.                               {
  222.                                 output_length = 0;
  223.                                 break;
  224.                               }
  225.                          if (sextet[2] < 0)
  226.                               output_length = 1;
  227.                          else
  228.                               if (sextet[3] < 0)
  229.                                     output_length = 2;
  230.                               else
  231.                                     output_length = 3;
  232.  
  233.                          output_buffer[0] = 4*sextet[0]+sextet[1]/16;
  234.                          output_buffer[1] = 16*(sextet[1]%16)+sextet[2]/4;
  235.                          output_buffer[2] = 64*(sextet[2]%64)+sextet[3];
  236.  
  237.                          fwrite(&output_buffer[0],output_length,1,outputfile);
  238.  
  239.                          output_size += output_length;
  240.  
  241.                          if (output_length < 3)
  242.                               break;
  243.                         }
  244.                   ReadInput(inputfile,input_string,max_line_length,&line_counter);
  245.  
  246.                   if (output_length < 3)
  247.                         break;
  248.                  }
  249.  
  250.             printf("%s succesfully created, lines = %d, bytes = %d\n",
  251.                          outputfilename,line_counter-start_line+1,output_size);
  252.  
  253.             fclose(outputfile);
  254.           }
  255.  
  256.      fclose(inputfile);
  257.  
  258.      if (files_processed == 0)
  259.           {
  260.             printf("No valid MIME input was detected\n");
  261.             return 4;
  262.           }
  263.      printf("%d output files created\n",files_processed);
  264.      return 0 ;
  265. }
  266.  
  267. int ValidMIME (char *input_string)
  268. {
  269.  if ((strlen(input_string)%4 > 0)  ||  (strlen(input_string)==0))
  270.       {
  271.         printf("Invalid MIME - %s\n",input_string);
  272.         return 0;
  273.       }
  274.  return (strspn(input_string,char_set) == strlen(input_string));
  275. }
  276.  
  277. char * ReadInput (FILE * inputfile, char * input_string,
  278.                         int input_string_size, int * line_counter)
  279. {
  280.  char * read_result;
  281.  int ii;
  282.  read_result = fgets(input_string,input_string_size,inputfile);
  283.  if (read_result != NULL)
  284.       {
  285.         ++(*line_counter);
  286.         ii = strlen(input_string)-1;
  287.         input_string[ii] = '\0';
  288.       }
  289.  return read_result;
  290. }
  291.  
  292.